# -*- coding: UTF-8 -*-
from LignePlancheDeJeu import *
from ConstantesFrogger import *
from _Outils.Job import *
from Position import *
import random
from _Outils.FroggerHelper import *
from DeathManager import *
import Pyro.core
import copy

class PlancheDeJeu(Pyro.core.ObjBase):
    def __init__(self, partie, joueur, largeur=15):
        Pyro.core.ObjBase.__init__(self)
        self.partie = partie
        self.largeur = largeur
        self.joueur = joueur
        
        self.listeStructLignes = []
        
        self.listeLignes = []
        
        self.enCours = False
        print 1
        self.refreshMap(joueur.niveau)
        print 99
        
        self.lock = threading.Lock()
        
        self.ratio = -1
        
        self.isFrozen = False
        
        self.deathManager = DeathManager(self.joueur, self)
        self.deathManager.jobDeath.start()
        
        #On ne touche pas !!!
        self.jobMoveMap = Job(0.05, self.moveMap)
        
    def refreshMap(self, niveau):
        self.creerStructureLignes(niveau)
        self.dessinerPlancheDeJeu(niveau)
        
        
    def creerStructureLignes(self, niveau):
        nbNiveauBase = 3
        self.listeStructLignes = []
        self.listeStructLignes.append(Trottoir)
        
        for i in range(niveau + nbNiveauBase):
            self.listeStructLignes.append(Rue)
            
        self.listeStructLignes.append(Trottoir)
        
        for i in range(niveau + nbNiveauBase):
            self.listeStructLignes.append(Riviere)
            
        self.listeStructLignes.append(Marais)
        
        
    def dessinerPlancheDeJeu(self, niveau):
        self.listeLignes = []
        
        rangeVitesses = [0.02,0.08,0.14]
        
        i = 0
        for ligne in self.listeStructLignes:
            direction = 1
            if i%2 == 1:
                direction = -1
                if ligne == Riviere:
                    vitesseDeBase = random.uniform(rangeVitesses[1], rangeVitesses[2]*niveau)
                    
            vitesseDeBase = random.uniform(rangeVitesses[0], rangeVitesses[1]*niveau)
            if ligne == Trottoir or ligne == Marais:
                self.listeLignes.append(ligne(self.largeur))
            else:
                self.listeLignes.append(ligne(self.largeur, vitesseDeBase*direction))
            i+=1
        
    def verifierCollisions(self):
        col = False
        rangeOccJoueur = self.lignesOccupeesJoueur()
        for i in range(rangeOccJoueur[0], rangeOccJoueur[1]+1):
            if not col:
                self.listeLignes[i].varFonction(self.joueur)
                
    def play(self):
        self.enCours = True
        self.deathManager.verifyState()
        self.deathManager.jobDeath.start()
        
        
    def pause(self):
        self.enCours = False
        self.deathManager.jobDeath.stop()
        self.jobMoveMap.stop()
        
        
    def lignesOccupeesJoueur(self):
        posBas = int(FroggerHelper.trunc(self.joueur.pos.y,0))
        posHaut = int(self.joueur.pos.y+self.joueur.hauteur-0.001)
        
        #depart = (len(self.listeLignes)-1) - posHaut
        #fin = (len(self.listeLignes)-1) - posBas
        
        return posBas, posHaut
        
        
    def moveMap(self):
        self.verifierCollisions()

        self.joueur.bouger()
        
        #Mouvement des lignes    
        for i in self.listeLignes:
            i.moveLine()            
        
        #Vérifier que la grenouille ne se fait pas trainer à l'extérieur de la planche de jeu                    
        self.verifier_Limites_De_La_Planche_De_Jeu_Pas_Dans_Le_Sens_De_Vitesse_Mais_De_La_Planche_Elle_Meme_Et_Sa_Situation_Relationnele_Avec_La_Grenouille()
        
        #self.verifierAnses()     
    
    def verifierAnses(self):
        """ Juste une fois apres le MJ, pas tt le temps. """
        nbAnses = 0
        for i in self.listeLignes:
            if isinstance(i, Marais):
                nbAnses += i.nbAnses
                
        if self.joueur.anses >= nbAnses:
            self.lock.acquire()
            self.joueur.monterNiveau()
            self.largeur += 2
            self.refreshMap(self.joueur.niveau)
            print "Changer de niveau"
            self.lock.release()
                
                    
    def verifier_Limites_De_La_Planche_De_Jeu_Pas_Dans_Le_Sens_De_Vitesse_Mais_De_La_Planche_Elle_Meme_Et_Sa_Situation_Relationnele_Avec_La_Grenouille(self):        
        #Vérifier chaque ligne à laquelle frogger touche
        rangeOccJoueur = self.lignesOccupeesJoueur()
        for i in range(rangeOccJoueur[0], rangeOccJoueur[1]+1):
            self.listeLignes[i].verifierLimitesGrenouille(self.joueur)
            
        if self.joueur.pos.y < 0:
            self.joueur.pos.y = 0
            
        elif self.joueur.pos.y > len(self.listeLignes)-1:
            self.joueur.pos.y = len(self.listeLignes)-1

    def deplacementGrenouille(self, status, direction):
        if not self.enCours:
            return
        
        if not self.isFrozen:
            self.joueur.move(status,direction)
        
        self.verifier_Limites_De_La_Planche_De_Jeu_Pas_Dans_Le_Sens_De_Vitesse_Mais_De_La_Planche_Elle_Meme_Et_Sa_Situation_Relationnele_Avec_La_Grenouille()
            
        #Vérification chaque fois au cas où le joueur pèse
        #continuelement sur la touche
        self.verifierCollisions()
        self.checkPositionJoueur()
        
    def getIsFrozen(self):
        return self.isFrozen
    
    def checkPositionJoueur(self):
        if self.joueur.joueurDansAnse:
            self.joueur.joueurDansAnse = False
            self.launchMiniJeu()
            self.joueur.allerAuDepart()
            print "LAUNCH MINI GAME"
    
    def isOnAnse(self):
        return self.joueur.joueurDansAnse

    def launchMiniJeu(self):
        #self.joueur.niveau += 1
        #self.dessinerPlancheDeJeu(self.joueur.niveau)
        self.partie.pauseGame()
        self.partie.setMiniGameTime(self, True)
        #self.joueur.allerAuDepart()

    def getJoueur(self):
        """Utile pour le réseau"""
        return self.joueur

    def getLargeur(self):
        """Utile pour le réseau... OK, il faut envoyer Olivier là dessus ASAP."""
        return self.largeur
    
    def getListeLignes(self):
        """Utile pour le réseau... 
        Il va falloir trouver un fix rapidement:
        Problème ici, on essaye d'envoyer des refs vers des fonctions (varFonction) qui sont sur le serveur au client... Ça fait chier le Pickle."""
        listePicklerSafe = []
        for i in self.listeLignes:
            ligne = copy.copy(i)
            ligne.varFonction = None
            ligneElemOld = ligne.listeElements
            ligne.listeElements = []
            for j in ligneElemOld:
                elem = copy.copy(j)
                elem.varFonction = None
                ligne.listeElements.append(elem)
            listePicklerSafe.append(ligne)
                
        return listePicklerSafe